W. S. Gilbert
William Shakespeare, Twelfth Night
Adlai Stevenson
W. H. Auden
a) struct.
b) dot (.), arrow (->).
c) private.
d) constructor.
e) private.
f) set.
g) Default memberwise copy (performed by the assignment operator).
h) public, private.
i) get.
j) interface.
l) class, struct.
m) public.
a) Error: Destructors are not allowed to return values or take arguments.
Correction: Remove the return type void and the parameter int from the declaration.
b) Error: Members cannot be explicitly initialized in the class definition.
Correction: Remove the explicit initialization from the class definition and initialize the data members in a constructor.
c) Error: Constructors are not allowed to return values.
Correction: Remove the return type int from the declaration.
The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P6_05.zip to your hard drive and unzip the program code.
The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P6_07.zip to your hard drive and unzip the program code.
The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P6_08.zip to your hard drive and unzip the program code.
The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P6_12.zip to your hard drive and unzip the program code.
The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P6_16.zip to your hard drive and unzip the program code.
6.1
6.2
6.3
6.4
6.5
6.6
6.7
6.9
6.10
6.11
6.12
6.13
6.14
6.15
6.16
6.17
6.19
6.20
Terminology
Figures
Now we begin our introduction to object orientation in C++. Why have we deferred object-oriented programming in C++ until Chapter 6? The answer is that the objects we will build will be composed in part of structured program pieces, so we needed to establish a basis in structured programming first.
Structures are aggregate data types built using elements of other types. Consider the following structure definition:
struct Time {
int hour; // 0-23
int minute; // 0-59
int second; // 0-59
};
The keyword struct introduces the structure definition.
The identifier Time is the structure tag that names the
structure definition and is used to declare variables of
the structure type. In this example, the new type name Time timeObject, timeArray[ 10 ], *timePtrdeclares timeObject to be a variable of type Time, timeArray to be an array with 10 elements of type Time, timePtr to be a pointer to a Time object and timeRef to be a reference to a Time object that is initialized with timeObject.&timeRef = timeObject;
Members of a structure (or of a class) are accessed using the member access operators--the dot operator (.) and the arrow operator (->). The dot operator accesses a structure or class member via the variable name for the object or via a reference to the object. For example, to print member hour of structure timeObject use the statement
cout << timeObject.hour;To print member hour of the structure referenced by timeRef use the statement
cout << timeRef.hour;
timePtr = &timeObject;The expression timePtr->hour is equivalent to (*timePtr).hour which dereferences the pointer and accesses the member hour using the dot operator.cout << timePtr->hour;
The 
Figure 6.1 creates the user-defined structure type Time
with three integer members: hour, minute, and
second. The program defines a single Time structure
called dinnerTime and uses the dot operator to
initialize the structure members with the values 18 for
hour, 30 for minute, and 0 for second. The program
then prints the time in military format (also called
"universal format") and standard format. Note that the
print functions receive references to constant Time
structures. This causes Time structures to be passed to 
thus eliminating the
copying overhead associated with passing structures to
functions by value-- 
and the use of const prevents the
Time structure from being modified by the print
functions. In Chapter 7, we discuss const objects and
const member functions.There are drawbacks to creating new data types with structures in this manner. Since initialization is not specifically required, it is possible to have uninitialized data and the consequent problems. Even if the data is initialized, it may not be initialized correctly. Invalid values can be assigned to the members of a structure (as we did in
Fig. 6.1) because the program has direct This is because the programmer directly
manipulates the data type. There is no "interface" to it
to ensure that the programmer uses the data type
correctly and to ensure that the data remains in a
consistent state. Classes enable the programmer to model objects that have attributes (represented as data members) and behaviors or operations (represented as member functions). Types containing data members and member functions are defined in C++ using the keyword class.
Figure 6.2
contains a simple definition for class Time.The class definition
terminates with a semicolon. Our Time class definition
and our Time structure definition each contain the three
integer members hour, minute, and second. 
Member access
specifiers are always followed by a colon (:) and can
appear multiple times and in any order in a class
definition. For the remainder of the text, we will refer to
the member access specifiers as public and private
(without the colon). In Chapter 9 we introduce a third Note that
no return type is specified for the constructor.Time sunset,// object of type Time
arrayOfTimes[ 5 ],
// array of Time objects
*pointerToTime,
// pointer to a Time object
&dinnerTime = sunset;
// reference to a Time object
The class name becomes a new type specifier. There
may be many objects of a class, just as there may be
many variables of a type such as int. The programmer
can create new class types as needed. This is one reason
why C++ is said to be an extensible language.Figure 6.3 uses the Time class. The program
instantiates a single object of class Time called t. When
the object is instantiated, the Time constructor is called
automatically and explicitly initializes each private
data member to 0. The time is then printed in military Again, note that the data members hour, minute, and second are preceded by the private member access specifier. A class's private data members are normally not accessible outside the class. (Again, we will see in Chapter 7 that friends of a class may access the class's private members.) The philosophy here is that the actual data representation used within the class is of no
Such information hiding
promotes program modifiability and simplifies the
client's perception of a class. Invalid values cannot Note that the data members of a class cannot be
initialized where they are declared in the class body.
These data members should be initialized by the class's
constructor, or they can be assigned values by "set"
functions.class's interface or public interface. but it is a good
programming practice to define the functions outside
the class definition.Fig. 6.3. Once a class is defined and its
member functions are declared, the member functions
must be defined. Each member function of the class can
be defined directly in the class body (rather than When a member function is defined after its
corresponding class definition, the function name is
preceded by the class name and the binary scope
resolution operator (::). Because different classes can
have the same member names, the scope resolution
operator "ties" the member name to the class name to
uniquely identify the member functions of a particular
class. If a member function is defined in a class definition,
the member function is automatically inlined. Member
functions defined outside a class definition may be
made inline by explicitly using the keyword inline.
Remember that the compiler reserves the right not to
inline any function.This makes
member function calls more concise than conventional
function calls in 
procedural programming. Interfaces do change, but Physically,
however, this is not true.A class's data members (variables declared in the class definition) and member functions (functions declared in the class definition) belong to that class's scope. Nonmember functions are defined at file scope.
Fig. 6.4 uses a simple class called
Count with public data member x of type int, and
public member function print to illustrate accessing
the members of a class with the member selection
operators. The program instantiates three variables
related to type Count--counter, counterRef (a
reference to a Count object), and counterPtr (a pointer
to a Count object). Variable counterRef is defined to
reference counter, and variable counterPtr is defined
to point to counter. It is important to note that data
member x has been made public here simply to
demonstrate how public members are accessed off
handles (i.e., a name, a reference or a pointer). As we One of the fundamental principles of good software engineering is to separate interface from implementation.
This makes it easier to modify
programs. As far as clients of a class are concerned,
changes in the class's implementation do not affect the
client as long as the class's interface originally provided
to the client is unchanged (the class's functionality
could be expanded beyond the original interface). Private members are listed in the class definition
in the header file, so these members are visible to
clients even though the clients may not access the
private members. In Chapter 7, we show how to use a
so-called proxy class to hide even the private data of a
class from clients of the class.Figure 6.5 splits the program of Fig. 6.3 into multiple
files. When building a C++ program, each class
definition is normally placed in a header file, and that Figure 6.5 consists of the header file time1.h in which
class Time is declared, the file time1.cpp in which the
member functions of class Time are defined, and the
file fig06_05.cpp in which function main is defined. Fig. 6.3.// prevent multiple inclusions of header fileWhen we build larger programs, other definitions and declarations will also be placed in header files. The preceding preprocessor directives prevent the code between #ifndef and #endif from being included if the name TIME1_H has been defined. If the header has not#ifndef TIME1_H
#define TIME1_H
...
#endif
Attempts to include a
header file multiple times (inadvertently) typically
occur in large programs with many header files that
may themselves include other header files. Note: The
convention we use for the symbolic constant name in
the preprocessor directives is simply the header file
name with the underscore character replacing the
period.The member access specifiers public and private (and protected as we will see in Chapter 9, "Inheritance") are used to control access to a class's data members and member functions.
The default access mode for classes
is private so all members after the class header and
before the first label are private. After each label, the
mode that was invoked by that label applies until the
next label or until the terminating right brace (}) of the
class definition. The labels public, private, and
protected may be repeated, but such usage is rare and
can be confusing.The private members of a class as well as the
definitions of its public member functions are not
accessible to the clients of a class. These components
form the implementation of the class. igure 6.6 demonstrates that private class members
are only accessible through the public class interface
using public member functions. When this program is
compiled, the compiler generates two errors stating that
the private member specified in each statement is not
accessible. Figure 6.6 includes time1.h and is compiled
with time1.cpp from Fig. 6.5.public, protected, or private. Access to a class's private data should be carefully
controlled by the use of member functions, called
access functions (also called accessor methods). For
example, to allow clients to read the value of private But a set member function
can provide data validation capabilities (such as range
checking) to ensure that the value is set properly. A set
function can also translate between the form of the data
used in the interface and the form used in the
implementation. A get function need not expose the
data in "raw" format; rather the get function can edit the
data and limit the view of the data the client will see.Not all member functions need be made public to serve as part of the interface of a class.
Some member
functions remain private and serve as utility functions
to the other functions of the class.Figure 6.7 demonstrates the notion of a utility function
(also called a helper function). A utility function is not
part of a class's interface; rather, it is a private member
function that supports the operation of the class's
public member functions. Utility functions are not
intended to be used by clients of a class. Note that main includes only a simple sequence of
member function calls--there are no control structures.When a class object is created, its members can be initialized by that class's constructor function. A constructor is a class member function with the same name as the class.
The programmer provides the
constructor which is then invoked automatically each
time an object of that class is created (instantiated).
Constructors may be overloaded to provide a variety of
means for initializing objects of a class. Data members
must either be initialized in a constructor of the class, or
their values may be set later after the object is created. The constructor from time1.cpp (
Fig. 6.5) initialized
hour, minute, and second to 0 (i.e., 12 midnight in
military time). Constructors can contain default
arguments. Figure 6.8 redefines the Time constructor
function to include default arguments of zero for each
variable. By providing default arguments to the
constructor, even if no values are provided in a
constructor call, the object is still guaranteed to be
initialized to a consistent state due to the default
arguments. A programmer-supplied constructor that In this program, the constructor calls member function setTime with the values passed to the constructor (or the default values) to ensure that the value supplied for hour is in the range 0 to 23, and that the values for minute and second are each in the range 0 to 59. If a value is out of range, it is set to zero by setTime (this is an example of ensuring that a data member remains in a consistent state).
This reduces the likelihood of a
programming error when altering the implementation. the constructor in the class definition
(which implicitly inlines the function definition).Fig. 6.8 initializes five Time objects--
one with all three arguments defaulted in the
constructor call, one with one argument specified, one
with two arguments specified, one with three arguments
specified, and one with three invalid arguments
specified. The contents of each object's data members
after instantiation and initialization are displayed. If no constructor is defined for a class, the compiler
creates a default constructor. Such a constructor does A destructor is a special member function of a class. The name of the destructor for a class is the tilde (~) character followed by the class name. This naming convention has intuitive appeal, because as we will see in a later chapter the tilde operator is the bitwise complement operator, and, in a sense, the destructor is the complement of the constructor.
A destructor receives no parameters and returns no
value. A class may have only one destructor--
destructor overloading is not allowed.Notice that destructors have not been provided for the
classes presented so far. We will soon see several
examples of classes with useful destructors. In Chapter
8, we will see that destructors are appropriate for
classes whose objects contain dynamically allocated
memory (for arrays and strings, for example). In Constructors and destructors are called automatically. The order in which these function calls are made depends on the order in which execution enters and leaves the scope in which objects are instantiated. Generally, destructor calls are made in the reverse order of the constructor calls. However, as we will see in
Fig.
6.9, the storage class of objects can alter the order in
which the destructors are called.Fig. 6.9 demonstrates the order in
which constructors and destructors are called for
objects of type CreateAndDestroy in several scopes.
The program defines first in global scope. Its
constructor is called as the program begins execution
and its destructor is called at program termination after
all other objects are destroyed. A class's private data members can be manipulated only by member functions (and friends) of the class. A typical manipulation might be the adjustment of a customer's bank balance (e.g., a private data member of a class BankAccount) by a member function computeInterest.
A public set
function could--and most likely would--carefully
scrutinize any attempt to modify the value of the data
member. This would ensure that the new value is
appropriate for that data item. For example, an attempt
to set the day of the month to 37 could be rejected, an
attempt to set a person's weight to a negative value
could be rejected, an attempt to set a numeric quantity
to an alphabetic value could be rejected, an attempt to
set a grade on an exam to 185 (when the proper range is
zero to 100) could be rejected, etc. valid. Figure 6.10 extends our Time class to include get and
set functions for the hour, minute, and second private
data members. The set functions strictly control the
setting of the data members. Attempts to set any data Using set functions is certainly important from a software engineering standpoint because they can perform validity checking.
Both set and get functions
have another important software engineering
advantage.A reference to an object is an alias for the name of the object and hence may be used on the left side of an assignment statement. In this context, the reference makes a perfectly acceptable lvalue that can receive a value.
One way to use this capability (unfortunately!) is
to have a public member function of a class return a
non-const reference to a private data member of that
class.Figure 6.11 uses a simplified Time class to demonstrate
returning a reference to a private data member. Such a The program begins by declaring Time object t and reference hourRef that is assigned the reference returned by the call t.badSetHour(20). The program displays the value of the alias hourRef. Next, the alias is used to set the value of hour to 30 (an invalid value) and the value is displayed again. Finally, the function call itself is used as an lvalue and assigned the value 74 (another invalid value), and the value is displayed.
The assignment operator (=) can be used to assign an object to another object of the same type. Such assignment is by default performed by memberwise copy--each member of one object is copied individually to the same member in another object (see
Fig. 6.12). (Note: Memberwise copy can cause serious
problems when used with a class whose data members
contain dynamically allocated storage; in Chapter 8,
"Operator Overloading," we will discuss these
problems and show how to deal with them.)Such passing and returning
is performed call-by-value by default--a copy of the
object is passed or returned (we present several
examples in Chapter 8, "Operator Overloading").People who write object-oriented programs concentrate on implementing useful classes. There is a tremendous opportunity to capture and catalog classes so that they can be accessed by large segments of the programming community. Many class libraries exist and others are being developed worldwide. There are efforts to make these libraries broadly accessible. Software is increasingly being constructed from existing, well- defined, carefully tested, well-documented, portable, widely available components. This kind of software reusability speeds the development of powerful, high-
In the "Thinking About Objects" sections of Chapters 1 through 5 we introduced the fundamentals of object orientation and walked you through an object-oriented design for an elevator simulator. In the body of Chapter 6, we introduced the details of programming and using C++ classes. At this point, you are ready (and probably eager!) to begin programming your elevator simulator.
1. For each of the classes you identified in the "Thinking About Objects" sections of Chapters 2 through 5, write an appropriate C++ class definition. For each class, include both a header file and a member function definition source file.
abstract data type
access function
arrow member selection operator (->)
attribute
B
behavior
binary scope resolution operator (::)
C
class
class definition
client of a class
consistent state
constructors
D
data member
default constructor
destructor
dot member selection operator (.)
E
encapsulation
file scope
G
get function
global object
H
header file
helper function
I
implementation of a class
information hiding
inline
interface of class
M
member access specifier
member function
member selection operators
memberwise copy
message sent to an object
object
object-oriented programming (OOP)
P
predicate function
principle of least privilege
private
procedural programming languages
programmer-defined type
protected
public interface
Q
query function
R
rapid applications development (RAD)
reuse
S
scope resolution operator (::)
self-referential structure
set function
software reuse
source-code file
static local object
structure
T
tilde character (~)
U
user-defined type
utility function
Fig. 6.2 Simple definition of class Time.
Fig. 6.3 Abstract data type Time implementation as a class.
Fig. 6.4 Accessing an object's data members and member functions through each type of object handle--through the object's name, through a reference, and through a pointer to the object.
Fig. 6.5 Separating Time class interface and implementation.
Fig. 6.6 Erroneous attempt to access private members of a class.
Fig. 6.7 Using a utility function.
Fig. 6.8 Using a constructor with default arguments.
Fig. 6.9 Demonstrating the order in which constructors and destructors are called.
Fig. 6.10 Using set and get functions.
Fig. 6.11 Returning a reference to a private data member.
Fig. 6.12 Assigning one object to another with default memberwise copy.
Fill in the blanks in each of the following:
a) The keyword _______ introduces a structure definition.
b) Class members are accessed via the _______ operator in conjunction with the name of an object of the class or via the ________operator in conjunction with a pointer to an object of the class.
c) Members of a class specified as _______ are accessible only to member functions of the class and friends of the class.
d) A _______ is a special member function used to initialize the data members of a class.
e) The default access for members of a class is _______ .
g) ________ can be used to assign an object of a class to another object of the same class.
h) Member functions of a class are normally made _______ and data members of a class are normally made ________.
i) A _______ function is used to retrieve values of private data of a class.
j) The set of public member functions of a class is referred to as the class's _____.
k) A class implementation is said to be hidden from its clients or ________.
l) The keywords _______ and _______ can be used to introduce a class definition.
Find the error(s) in each of the following and explain how to correct it.
a) Assume the following prototype is declared in class Time.
void ~Time( int );b) The following is a partial definition of class Time.
class Time {
public:
// function prototypes
private:
int hour = 0;
int minute = 0;
int second = 0;
};c) Assume the following prototype is declared in class Employee.
int Employee( const char *, const char * );
What is the purpose of the scope resolution operator?
Compare and contrast the notions of struct and class in C++.
Provide a constructor that is capable of using the current time from the time() function--declared in the C Standard Library header time.h--to initialize an object of the Time class.
Create a class called Complex for performing arithmetic with complex numbers. Write a driver program to test your class.
Complex numbers have the form
realPart + imaginaryPart * iwhere i is
Use floating-point variables to represent the private data of the class. Provide a constructor function that enables an object of this class to be initialized when it is declared. The constructor should contain default values in case no initializers are provided. Provide public member functions for each of the following:
b) Subtraction of two Complex numbers: The real part of the right operand is subtracted from the real part of the left operand and the imaginary part of the right operand is subtracted from the imaginary part of the left operand.
c) Printing Complex numbers in the form (a, b) where a is the real part and b is the imaginary part.
Create a class called Rational for performing arithmetic with fractions. Write a driver program to test your class.
Use integer variables to represent the private data of the class--the numerator and the denominator. Provide a constructor function that enables an object of this class to be initialized when it is declared. The constructor should contain default values in case no initializers are provided and should store the fraction in reduced form (i.e., the fraction
would be stored in the object as 1 in the numerator and 2 in the denominator). Provide public member functions for each of the following:
b) Subtraction of two Rational numbers. The result should be stored in reduced form.
c) Multiplication of two Rational numbers. The result should be stored in reduced form.
d) Division of two Rational numbers. The result should be stored in reduced form.
e) Printing Rational numbers in the form a/b where a is the numerator and b is the denominator.
f) Printing Rational numbers in floating-point format.
Modify the Time class of
Fig. 6.10 to include a tick member function that
increments the time stored in a Time object by one second. The Time object
should always remain in a consistent state. Write a driver program that tests the
tick member function in a loop that prints the time in standard format during
each iteration of the loop to illustrate that the tick member function works
correctly. Be sure to test the following cases:a) Incrementing into the next minute.
b) Incrementing into the next hour.
c) Incrementing into the next day (i.e., 11:59:59 PM to 12:00:00 AM).
Modify the Date class of
Fig. 6.12 to perform error checking on the initializer
values for data members month, day, and year. Also, provide a member
function nextDay to increment the day by one. The Date object should always
remain in a consistent state. Write a driver program that tests the nextDay
function in a loop that prints the date during each iteration of the loop to
illustrate that the nextDay function works correctly. Be sure to test the following
cases:a) Incrementing into the next month.
b) Incrementing into the next year.
Combine the modified Time class of
Exercise 6.8 and the modified Date class
of Exercise 6.9 into one class called DateAndTime (in Chapter 9 we will
discuss inheritance which will enable us to accomplish this task quickly without
modifying the existing class definitions). Modify the tick function to call the
nextDay function if the time is incremented into the next day. Modify function
printStandard and printMilitary to output the date in addition to the time.
Write a driver program to test the new class DateAndTime. Specifically test
incrementing the time into the next day.Modify the set functions in the program of
Fig. 6.10 to return appropriate error
values if an attempt is made to set a data member of an object of class Time to
an invalid value. Create a class Rectangle. The class has attributes length and width, each of which defaults to 1. It has member functions that calculate the perimeter and the area of the rectangle. It has set and get functions for both length and width. The set functions should verify that length and width are each floating-point numbers larger than 0.0 and less than 20.0.
Create a more sophisticated Rectangle class than the one you created in
Exercise 6.12. This class stores only the Cartesian coordinates of the four
corners of the rectangle. The constructor calls a set function that accepts four
sets of coordinates and verifies that each of these is in the first quadrant with no
single x or y coordinate larger than 20.0. The set function also verifies that the
supplied coordinates do, in fact, specify a rectangle. Member functions calculate
the length, width, perimeter, and area. The length is the larger of the two
dimensions. Include a predicate function square that determines if the rectangle
is a square. Modify the Rectangle class of
Exercise 6.13 to include a draw function that
displays the rectangle inside a 25-by-25 box enclosing the portion of the first
quadrant in which the rectangle resides. Include a setFillCharacter function to
specify the character out of which the body of the rectangle will be drawn.
Include a setPerimeterCharacter function to specify the character that will be
used to draw the border of the rectangle. If you feel ambitious you might include
functions to scale the size of the rectangle, rotate it, and move it around within
the designated portion of the first quadrant.Create a class HugeInteger that uses a 40-element array of digits to store integers as large as 40-digits each. Provide member functions inputHugeInteger, outputHugeInteger, addHugeIntegers, and substractHugeIntegers. For comparing HugeInteger objects provide functions isEqualTo, isNotEqualTo, isGreaterThan, isLessThan, IsGreaterThanOrEqualTo, and isLessThanOrEqualTo--each of these is a "predicate" function that simply returns true if the relationship holds between the two huge integers and returns false if the relationship does not hold. Provide a predicate function isZero. If you feel ambitious, also provide member functions multiplyHugeIntegers, divideHugeIntegers, and modulusHugeIntegers.
Create a class TicTacToe that will enable you to write a complete program to play the game of tic-tac-toe. The class contains as private data a 3-by-3 double array of integers. The constructor should initialize the empty board to all zeros. Allow two human players. Wherever the first player moves, place a 1 in the specified square; place a 2 wherever the second player moves. Each move must be to an empty square. After each move, determine if the game has been won or if the game is a draw. If you feel ambitious, modify your program so that the computer makes the moves for one of the players automatically. Also, allow the player to specify whether he or she wants to go first or second. If you feel exceptionally ambitious, develop a program that will play three-dimensional tic- tac-toe on a 4-by-4-by-4 board (Caution: This is an extremely challenging project that could take many weeks of effort!).